//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS NetworkManager service.
///
/// Amazon Web Services enables you to centrally manage your Amazon Web Services Cloud WAN core network and your Transit Gateway network across Amazon Web Services accounts, Regions, and on-premises locations.
public struct NetworkManager: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the NetworkManager client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: nil,
            partition: partition,
            serviceName: "NetworkManager",
            serviceIdentifier: "networkmanager",
            serviceProtocol: .restjson,
            apiVersion: "2019-07-05",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            partitionEndpoints: Self.partitionEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: NetworkManagerErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "aws-global": "networkmanager.us-west-2.amazonaws.com",
        "aws-us-gov-global": "networkmanager.us-gov-west-1.amazonaws.com"
    ]}

    /// Default endpoint and region to use for each partition
    static var partitionEndpoints: [AWSPartition: (endpoint: String, region: SotoCore.Region)] {[
        .aws: (endpoint: "aws-global", region: .uswest2),
        .awsusgov: (endpoint: "aws-us-gov-global", region: .usgovwest1)
    ]}

    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "aws-global": "networkmanager.us-west-2.api.aws",
            "aws-us-gov-global": "networkmanager.us-gov-west-1.api.aws"
        ]),
        [.dualstack, .fips]: .init(endpoints: [
            "aws-global": "networkmanager-fips.us-west-2.api.aws",
            "aws-us-gov-global": "networkmanager.us-gov-west-1.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "aws-global": "networkmanager-fips.us-west-2.amazonaws.com",
            "aws-us-gov-global": "networkmanager.us-gov-west-1.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Accepts a core network attachment request.  Once the attachment request is accepted by a core network owner, the attachment is created and connected to a core network.
    @Sendable
    @inlinable
    public func acceptAttachment(_ input: AcceptAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptAttachmentResponse {
        try await self.client.execute(
            operation: "AcceptAttachment", 
            path: "/attachments/{AttachmentId}/accept", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Accepts a core network attachment request.  Once the attachment request is accepted by a core network owner, the attachment is created and connected to a core network.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptAttachmentResponse {
        let input = AcceptAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.acceptAttachment(input, logger: logger)
    }

    /// Associates a core network Connect peer with a device and optionally, with a link.  If you specify a link, it must be associated with the specified device. You can only associate core network Connect peers that have been created on a core network Connect attachment on a core network.
    @Sendable
    @inlinable
    public func associateConnectPeer(_ input: AssociateConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateConnectPeerResponse {
        try await self.client.execute(
            operation: "AssociateConnectPeer", 
            path: "/global-networks/{GlobalNetworkId}/connect-peer-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a core network Connect peer with a device and optionally, with a link.  If you specify a link, it must be associated with the specified device. You can only associate core network Connect peers that have been created on a core network Connect attachment on a core network.
    ///
    /// Parameters:
    ///   - connectPeerId: The ID of the Connect peer.
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of your global network.
    ///   - linkId: The ID of the link.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateConnectPeer(
        connectPeerId: String,
        deviceId: String,
        globalNetworkId: String,
        linkId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateConnectPeerResponse {
        let input = AssociateConnectPeerRequest(
            connectPeerId: connectPeerId, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.associateConnectPeer(input, logger: logger)
    }

    /// Associates a customer gateway with a device and optionally, with a link. If you specify a link, it must be associated with the specified device.  You can only associate customer gateways that are connected to a VPN attachment on a transit gateway or core network registered in your global network. When you register a transit gateway or core network, customer gateways that are connected to the transit gateway are automatically included in the global network. To list customer gateways that are connected to a transit gateway, use the DescribeVpnConnections EC2 API and filter by transit-gateway-id. You cannot associate a customer gateway with more than one device and link.
    @Sendable
    @inlinable
    public func associateCustomerGateway(_ input: AssociateCustomerGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateCustomerGatewayResponse {
        try await self.client.execute(
            operation: "AssociateCustomerGateway", 
            path: "/global-networks/{GlobalNetworkId}/customer-gateway-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a customer gateway with a device and optionally, with a link. If you specify a link, it must be associated with the specified device.  You can only associate customer gateways that are connected to a VPN attachment on a transit gateway or core network registered in your global network. When you register a transit gateway or core network, customer gateways that are connected to the transit gateway are automatically included in the global network. To list customer gateways that are connected to a transit gateway, use the DescribeVpnConnections EC2 API and filter by transit-gateway-id. You cannot associate a customer gateway with more than one device and link.
    ///
    /// Parameters:
    ///   - customerGatewayArn: The Amazon Resource Name (ARN) of the customer gateway.
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateCustomerGateway(
        customerGatewayArn: String,
        deviceId: String,
        globalNetworkId: String,
        linkId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateCustomerGatewayResponse {
        let input = AssociateCustomerGatewayRequest(
            customerGatewayArn: customerGatewayArn, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.associateCustomerGateway(input, logger: logger)
    }

    /// Associates a link to a device. A device can be associated to multiple links and a link can be associated to multiple devices. The device and link must be in the same global network and the same site.
    @Sendable
    @inlinable
    public func associateLink(_ input: AssociateLinkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateLinkResponse {
        try await self.client.execute(
            operation: "AssociateLink", 
            path: "/global-networks/{GlobalNetworkId}/link-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a link to a device. A device can be associated to multiple links and a link can be associated to multiple devices. The device and link must be in the same global network and the same site.
    ///
    /// Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateLink(
        deviceId: String,
        globalNetworkId: String,
        linkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateLinkResponse {
        let input = AssociateLinkRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.associateLink(input, logger: logger)
    }

    /// Associates a transit gateway Connect peer with a device, and optionally, with a link. If you specify a link, it must be associated with the specified device.  You can only associate transit gateway Connect peers that have been created on a transit gateway that's registered in your global network. You cannot associate a transit gateway Connect peer with more than one device and link.
    @Sendable
    @inlinable
    public func associateTransitGatewayConnectPeer(_ input: AssociateTransitGatewayConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateTransitGatewayConnectPeerResponse {
        try await self.client.execute(
            operation: "AssociateTransitGatewayConnectPeer", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a transit gateway Connect peer with a device, and optionally, with a link. If you specify a link, it must be associated with the specified device.  You can only associate transit gateway Connect peers that have been created on a transit gateway that's registered in your global network. You cannot associate a transit gateway Connect peer with more than one device and link.
    ///
    /// Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - transitGatewayConnectPeerArn: The Amazon Resource Name (ARN) of the Connect peer.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateTransitGatewayConnectPeer(
        deviceId: String,
        globalNetworkId: String,
        linkId: String? = nil,
        transitGatewayConnectPeerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateTransitGatewayConnectPeerResponse {
        let input = AssociateTransitGatewayConnectPeerRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId, 
            transitGatewayConnectPeerArn: transitGatewayConnectPeerArn
        )
        return try await self.associateTransitGatewayConnectPeer(input, logger: logger)
    }

    /// Creates a core network Connect attachment from a specified core network attachment.  A core network Connect attachment is a GRE-based tunnel attachment that you can use to establish a connection between a core network and an appliance. A core network Connect attachment uses an existing VPC attachment as the underlying transport mechanism.
    @Sendable
    @inlinable
    public func createConnectAttachment(_ input: CreateConnectAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConnectAttachmentResponse {
        try await self.client.execute(
            operation: "CreateConnectAttachment", 
            path: "/connect-attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a core network Connect attachment from a specified core network attachment.  A core network Connect attachment is a GRE-based tunnel attachment that you can use to establish a connection between a core network and an appliance. A core network Connect attachment uses an existing VPC attachment as the underlying transport mechanism.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - coreNetworkId: The ID of a core network where you want to create the attachment.
    ///   - edgeLocation: The Region where the edge is located.
    ///   - options: Options for creating an attachment.
    ///   - tags: The list of key-value tags associated with the request.
    ///   - transportAttachmentId: The ID of the attachment between the two connections.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnectAttachment(
        clientToken: String? = CreateConnectAttachmentRequest.idempotencyToken(),
        coreNetworkId: String,
        edgeLocation: String,
        options: ConnectAttachmentOptions,
        tags: [Tag]? = nil,
        transportAttachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectAttachmentResponse {
        let input = CreateConnectAttachmentRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            edgeLocation: edgeLocation, 
            options: options, 
            tags: tags, 
            transportAttachmentId: transportAttachmentId
        )
        return try await self.createConnectAttachment(input, logger: logger)
    }

    /// Creates a core network Connect peer for a specified core network connect attachment between a core network and an appliance. The peer address and transit gateway address must be the same IP address family (IPv4 or IPv6).
    @Sendable
    @inlinable
    public func createConnectPeer(_ input: CreateConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConnectPeerResponse {
        try await self.client.execute(
            operation: "CreateConnectPeer", 
            path: "/connect-peers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a core network Connect peer for a specified core network connect attachment between a core network and an appliance. The peer address and transit gateway address must be the same IP address family (IPv4 or IPv6).
    ///
    /// Parameters:
    ///   - bgpOptions: The Connect peer BGP options. This only applies only when the protocol is GRE.
    ///   - clientToken: The client token associated with the request.
    ///   - connectAttachmentId: The ID of the connection attachment.
    ///   - coreNetworkAddress: A Connect peer core network address. This only applies only when the protocol is GRE.
    ///   - insideCidrBlocks: The inside IP addresses used for BGP peering.
    ///   - peerAddress: The Connect peer address.
    ///   - subnetArn: The subnet ARN for the Connect peer. This only applies only when the protocol is NO_ENCAP.
    ///   - tags: The tags associated with the peer request.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnectPeer(
        bgpOptions: BgpOptions? = nil,
        clientToken: String? = CreateConnectPeerRequest.idempotencyToken(),
        connectAttachmentId: String,
        coreNetworkAddress: String? = nil,
        insideCidrBlocks: [String]? = nil,
        peerAddress: String,
        subnetArn: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectPeerResponse {
        let input = CreateConnectPeerRequest(
            bgpOptions: bgpOptions, 
            clientToken: clientToken, 
            connectAttachmentId: connectAttachmentId, 
            coreNetworkAddress: coreNetworkAddress, 
            insideCidrBlocks: insideCidrBlocks, 
            peerAddress: peerAddress, 
            subnetArn: subnetArn, 
            tags: tags
        )
        return try await self.createConnectPeer(input, logger: logger)
    }

    /// Creates a connection between two devices. The devices can be a physical or virtual appliance that connects to a third-party appliance in a VPC, or a physical appliance that connects to another physical appliance in an on-premises network.
    @Sendable
    @inlinable
    public func createConnection(_ input: CreateConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConnectionResponse {
        try await self.client.execute(
            operation: "CreateConnection", 
            path: "/global-networks/{GlobalNetworkId}/connections", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a connection between two devices. The devices can be a physical or virtual appliance that connects to a third-party appliance in a VPC, or a physical appliance that connects to another physical appliance in an on-premises network.
    ///
    /// Parameters:
    ///   - connectedDeviceId: The ID of the second device in the connection.
    ///   - connectedLinkId: The ID of the link for the second device.
    ///   - description: A description of the connection. Length Constraints: Maximum length of 256 characters.
    ///   - deviceId: The ID of the first device in the connection.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link for the first device.
    ///   - tags: The tags to apply to the resource during creation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnection(
        connectedDeviceId: String,
        connectedLinkId: String? = nil,
        description: String? = nil,
        deviceId: String,
        globalNetworkId: String,
        linkId: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectionResponse {
        let input = CreateConnectionRequest(
            connectedDeviceId: connectedDeviceId, 
            connectedLinkId: connectedLinkId, 
            description: description, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId, 
            tags: tags
        )
        return try await self.createConnection(input, logger: logger)
    }

    /// Creates a core network as part of your global network, and optionally, with a core network policy.
    @Sendable
    @inlinable
    public func createCoreNetwork(_ input: CreateCoreNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCoreNetworkResponse {
        try await self.client.execute(
            operation: "CreateCoreNetwork", 
            path: "/core-networks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a core network as part of your global network, and optionally, with a core network policy.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with a core network request.
    ///   - description: The description of a core network.
    ///   - globalNetworkId: The ID of the global network that a core network will be a part of.
    ///   - policyDocument: The policy document for creating a core network.
    ///   - tags: Key-value tags associated with a core network request.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCoreNetwork(
        clientToken: String? = CreateCoreNetworkRequest.idempotencyToken(),
        description: String? = nil,
        globalNetworkId: String,
        policyDocument: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCoreNetworkResponse {
        let input = CreateCoreNetworkRequest(
            clientToken: clientToken, 
            description: description, 
            globalNetworkId: globalNetworkId, 
            policyDocument: policyDocument, 
            tags: tags
        )
        return try await self.createCoreNetwork(input, logger: logger)
    }

    /// Creates a new device in a global network. If you specify both a site ID and a location, the location of the site is used for visualization in the Network Manager console.
    @Sendable
    @inlinable
    public func createDevice(_ input: CreateDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDeviceResponse {
        try await self.client.execute(
            operation: "CreateDevice", 
            path: "/global-networks/{GlobalNetworkId}/devices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new device in a global network. If you specify both a site ID and a location, the location of the site is used for visualization in the Network Manager console.
    ///
    /// Parameters:
    ///   - awsLocation: The Amazon Web Services location of the device, if applicable. For an on-premises device, you can omit this parameter.
    ///   - description: A description of the device. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - location: The location of the device.
    ///   - model: The model of the device. Constraints: Maximum length of 128 characters.
    ///   - serialNumber: The serial number of the device. Constraints: Maximum length of 128 characters.
    ///   - siteId: The ID of the site.
    ///   - tags: The tags to apply to the resource during creation.
    ///   - type: The type of the device.
    ///   - vendor: The vendor of the device. Constraints: Maximum length of 128 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDevice(
        awsLocation: AWSLocation? = nil,
        description: String? = nil,
        globalNetworkId: String,
        location: Location? = nil,
        model: String? = nil,
        serialNumber: String? = nil,
        siteId: String? = nil,
        tags: [Tag]? = nil,
        type: String? = nil,
        vendor: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDeviceResponse {
        let input = CreateDeviceRequest(
            awsLocation: awsLocation, 
            description: description, 
            globalNetworkId: globalNetworkId, 
            location: location, 
            model: model, 
            serialNumber: serialNumber, 
            siteId: siteId, 
            tags: tags, 
            type: type, 
            vendor: vendor
        )
        return try await self.createDevice(input, logger: logger)
    }

    /// Creates an Amazon Web Services Direct Connect gateway attachment
    @Sendable
    @inlinable
    public func createDirectConnectGatewayAttachment(_ input: CreateDirectConnectGatewayAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDirectConnectGatewayAttachmentResponse {
        try await self.client.execute(
            operation: "CreateDirectConnectGatewayAttachment", 
            path: "/direct-connect-gateway-attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Web Services Direct Connect gateway attachment
    ///
    /// Parameters:
    ///   - clientToken: client token
    ///   - coreNetworkId: The ID of the Cloud WAN core network that the Direct Connect gateway attachment should be attached to.
    ///   - directConnectGatewayArn: The ARN of the Direct Connect gateway attachment.
    ///   - edgeLocations: One or more core network edge locations that the Direct Connect gateway attachment is associated with.
    ///   - tags: The key value tags to apply to the Direct Connect gateway attachment during creation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDirectConnectGatewayAttachment(
        clientToken: String? = CreateDirectConnectGatewayAttachmentRequest.idempotencyToken(),
        coreNetworkId: String,
        directConnectGatewayArn: String,
        edgeLocations: [String],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDirectConnectGatewayAttachmentResponse {
        let input = CreateDirectConnectGatewayAttachmentRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            directConnectGatewayArn: directConnectGatewayArn, 
            edgeLocations: edgeLocations, 
            tags: tags
        )
        return try await self.createDirectConnectGatewayAttachment(input, logger: logger)
    }

    /// Creates a new, empty global network.
    @Sendable
    @inlinable
    public func createGlobalNetwork(_ input: CreateGlobalNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGlobalNetworkResponse {
        try await self.client.execute(
            operation: "CreateGlobalNetwork", 
            path: "/global-networks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new, empty global network.
    ///
    /// Parameters:
    ///   - description: A description of the global network. Constraints: Maximum length of 256 characters.
    ///   - tags: The tags to apply to the resource during creation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGlobalNetwork(
        description: String? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGlobalNetworkResponse {
        let input = CreateGlobalNetworkRequest(
            description: description, 
            tags: tags
        )
        return try await self.createGlobalNetwork(input, logger: logger)
    }

    /// Creates a new link for a specified site.
    @Sendable
    @inlinable
    public func createLink(_ input: CreateLinkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLinkResponse {
        try await self.client.execute(
            operation: "CreateLink", 
            path: "/global-networks/{GlobalNetworkId}/links", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new link for a specified site.
    ///
    /// Parameters:
    ///   - bandwidth:  The upload speed and download speed in Mbps.
    ///   - description: A description of the link. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - provider: The provider of the link. Constraints: Maximum length of 128 characters. Cannot include the following characters: | \ ^
    ///   - siteId: The ID of the site.
    ///   - tags: The tags to apply to the resource during creation.
    ///   - type: The type of the link. Constraints: Maximum length of 128 characters. Cannot include the following characters: | \ ^
    ///   - logger: Logger use during operation
    @inlinable
    public func createLink(
        bandwidth: Bandwidth,
        description: String? = nil,
        globalNetworkId: String,
        provider: String? = nil,
        siteId: String,
        tags: [Tag]? = nil,
        type: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLinkResponse {
        let input = CreateLinkRequest(
            bandwidth: bandwidth, 
            description: description, 
            globalNetworkId: globalNetworkId, 
            provider: provider, 
            siteId: siteId, 
            tags: tags, 
            type: type
        )
        return try await self.createLink(input, logger: logger)
    }

    /// Creates a new site in a global network.
    @Sendable
    @inlinable
    public func createSite(_ input: CreateSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSiteResponse {
        try await self.client.execute(
            operation: "CreateSite", 
            path: "/global-networks/{GlobalNetworkId}/sites", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new site in a global network.
    ///
    /// Parameters:
    ///   - description: A description of your site. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - location: The site location. This information is used for visualization in the Network Manager console. If you specify the address, the latitude and longitude are automatically calculated.    Address: The physical address of the site.    Latitude: The latitude of the site.     Longitude: The longitude of the site.
    ///   - tags: The tags to apply to the resource during creation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSite(
        description: String? = nil,
        globalNetworkId: String,
        location: Location? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSiteResponse {
        let input = CreateSiteRequest(
            description: description, 
            globalNetworkId: globalNetworkId, 
            location: location, 
            tags: tags
        )
        return try await self.createSite(input, logger: logger)
    }

    /// Creates an Amazon Web Services site-to-site VPN attachment on an edge location of a core network.
    @Sendable
    @inlinable
    public func createSiteToSiteVpnAttachment(_ input: CreateSiteToSiteVpnAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSiteToSiteVpnAttachmentResponse {
        try await self.client.execute(
            operation: "CreateSiteToSiteVpnAttachment", 
            path: "/site-to-site-vpn-attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Web Services site-to-site VPN attachment on an edge location of a core network.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - coreNetworkId: The ID of a core network where you're creating a site-to-site VPN attachment.
    ///   - tags: The tags associated with the request.
    ///   - vpnConnectionArn: The ARN identifying the VPN attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSiteToSiteVpnAttachment(
        clientToken: String? = CreateSiteToSiteVpnAttachmentRequest.idempotencyToken(),
        coreNetworkId: String,
        tags: [Tag]? = nil,
        vpnConnectionArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSiteToSiteVpnAttachmentResponse {
        let input = CreateSiteToSiteVpnAttachmentRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            tags: tags, 
            vpnConnectionArn: vpnConnectionArn
        )
        return try await self.createSiteToSiteVpnAttachment(input, logger: logger)
    }

    /// Creates a transit gateway peering connection.
    @Sendable
    @inlinable
    public func createTransitGatewayPeering(_ input: CreateTransitGatewayPeeringRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTransitGatewayPeeringResponse {
        try await self.client.execute(
            operation: "CreateTransitGatewayPeering", 
            path: "/transit-gateway-peerings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a transit gateway peering connection.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - coreNetworkId: The ID of a core network.
    ///   - tags: The list of key-value tags associated with the request.
    ///   - transitGatewayArn: The ARN of the transit gateway for the peering request.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTransitGatewayPeering(
        clientToken: String? = CreateTransitGatewayPeeringRequest.idempotencyToken(),
        coreNetworkId: String,
        tags: [Tag]? = nil,
        transitGatewayArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTransitGatewayPeeringResponse {
        let input = CreateTransitGatewayPeeringRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            tags: tags, 
            transitGatewayArn: transitGatewayArn
        )
        return try await self.createTransitGatewayPeering(input, logger: logger)
    }

    /// Creates a transit gateway route table attachment.
    @Sendable
    @inlinable
    public func createTransitGatewayRouteTableAttachment(_ input: CreateTransitGatewayRouteTableAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTransitGatewayRouteTableAttachmentResponse {
        try await self.client.execute(
            operation: "CreateTransitGatewayRouteTableAttachment", 
            path: "/transit-gateway-route-table-attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a transit gateway route table attachment.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - peeringId: The ID of the peer for the
    ///   - tags: The list of key-value tags associated with the request.
    ///   - transitGatewayRouteTableArn: The ARN of the transit gateway route table for the attachment request. For example, "TransitGatewayRouteTableArn": "arn:aws:ec2:us-west-2:123456789012:transit-gateway-route-table/tgw-rtb-9876543210123456".
    ///   - logger: Logger use during operation
    @inlinable
    public func createTransitGatewayRouteTableAttachment(
        clientToken: String? = CreateTransitGatewayRouteTableAttachmentRequest.idempotencyToken(),
        peeringId: String,
        tags: [Tag]? = nil,
        transitGatewayRouteTableArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTransitGatewayRouteTableAttachmentResponse {
        let input = CreateTransitGatewayRouteTableAttachmentRequest(
            clientToken: clientToken, 
            peeringId: peeringId, 
            tags: tags, 
            transitGatewayRouteTableArn: transitGatewayRouteTableArn
        )
        return try await self.createTransitGatewayRouteTableAttachment(input, logger: logger)
    }

    /// Creates a VPC attachment on an edge location of a core network.
    @Sendable
    @inlinable
    public func createVpcAttachment(_ input: CreateVpcAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVpcAttachmentResponse {
        try await self.client.execute(
            operation: "CreateVpcAttachment", 
            path: "/vpc-attachments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a VPC attachment on an edge location of a core network.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - coreNetworkId: The ID of a core network for the VPC attachment.
    ///   - options: Options for the VPC attachment.
    ///   - subnetArns: The subnet ARN of the VPC attachment.
    ///   - tags: The key-value tags associated with the request.
    ///   - vpcArn: The ARN of the VPC.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVpcAttachment(
        clientToken: String? = CreateVpcAttachmentRequest.idempotencyToken(),
        coreNetworkId: String,
        options: VpcOptions? = nil,
        subnetArns: [String],
        tags: [Tag]? = nil,
        vpcArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVpcAttachmentResponse {
        let input = CreateVpcAttachmentRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            options: options, 
            subnetArns: subnetArns, 
            tags: tags, 
            vpcArn: vpcArn
        )
        return try await self.createVpcAttachment(input, logger: logger)
    }

    /// Deletes an attachment. Supports all attachment types.
    @Sendable
    @inlinable
    public func deleteAttachment(_ input: DeleteAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAttachmentResponse {
        try await self.client.execute(
            operation: "DeleteAttachment", 
            path: "/attachments/{AttachmentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an attachment. Supports all attachment types.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAttachmentResponse {
        let input = DeleteAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.deleteAttachment(input, logger: logger)
    }

    /// Deletes a Connect peer.
    @Sendable
    @inlinable
    public func deleteConnectPeer(_ input: DeleteConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConnectPeerResponse {
        try await self.client.execute(
            operation: "DeleteConnectPeer", 
            path: "/connect-peers/{ConnectPeerId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Connect peer.
    ///
    /// Parameters:
    ///   - connectPeerId: The ID of the deleted Connect peer.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConnectPeer(
        connectPeerId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConnectPeerResponse {
        let input = DeleteConnectPeerRequest(
            connectPeerId: connectPeerId
        )
        return try await self.deleteConnectPeer(input, logger: logger)
    }

    /// Deletes the specified connection in your global network.
    @Sendable
    @inlinable
    public func deleteConnection(_ input: DeleteConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConnectionResponse {
        try await self.client.execute(
            operation: "DeleteConnection", 
            path: "/global-networks/{GlobalNetworkId}/connections/{ConnectionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified connection in your global network.
    ///
    /// Parameters:
    ///   - connectionId: The ID of the connection.
    ///   - globalNetworkId: The ID of the global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConnection(
        connectionId: String,
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConnectionResponse {
        let input = DeleteConnectionRequest(
            connectionId: connectionId, 
            globalNetworkId: globalNetworkId
        )
        return try await self.deleteConnection(input, logger: logger)
    }

    /// Deletes a core network along with all core network policies. This can only be done if there are no attachments on a core network.
    @Sendable
    @inlinable
    public func deleteCoreNetwork(_ input: DeleteCoreNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCoreNetworkResponse {
        try await self.client.execute(
            operation: "DeleteCoreNetwork", 
            path: "/core-networks/{CoreNetworkId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a core network along with all core network policies. This can only be done if there are no attachments on a core network.
    ///
    /// Parameters:
    ///   - coreNetworkId: The network ID of the deleted core network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCoreNetwork(
        coreNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCoreNetworkResponse {
        let input = DeleteCoreNetworkRequest(
            coreNetworkId: coreNetworkId
        )
        return try await self.deleteCoreNetwork(input, logger: logger)
    }

    /// Deletes a policy version from a core network. You can't delete the current LIVE policy.
    @Sendable
    @inlinable
    public func deleteCoreNetworkPolicyVersion(_ input: DeleteCoreNetworkPolicyVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCoreNetworkPolicyVersionResponse {
        try await self.client.execute(
            operation: "DeleteCoreNetworkPolicyVersion", 
            path: "/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a policy version from a core network. You can't delete the current LIVE policy.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network for the deleted policy.
    ///   - policyVersionId: The version ID of the deleted policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCoreNetworkPolicyVersion(
        coreNetworkId: String,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCoreNetworkPolicyVersionResponse {
        let input = DeleteCoreNetworkPolicyVersionRequest(
            coreNetworkId: coreNetworkId, 
            policyVersionId: policyVersionId
        )
        return try await self.deleteCoreNetworkPolicyVersion(input, logger: logger)
    }

    /// Deletes an existing device. You must first disassociate the device from any links and customer gateways.
    @Sendable
    @inlinable
    public func deleteDevice(_ input: DeleteDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDeviceResponse {
        try await self.client.execute(
            operation: "DeleteDevice", 
            path: "/global-networks/{GlobalNetworkId}/devices/{DeviceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing device. You must first disassociate the device from any links and customer gateways.
    ///
    /// Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDevice(
        deviceId: String,
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDeviceResponse {
        let input = DeleteDeviceRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId
        )
        return try await self.deleteDevice(input, logger: logger)
    }

    /// Deletes an existing global network. You must first delete all global network objects (devices, links, and sites), deregister all transit gateways, and delete any core networks.
    @Sendable
    @inlinable
    public func deleteGlobalNetwork(_ input: DeleteGlobalNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGlobalNetworkResponse {
        try await self.client.execute(
            operation: "DeleteGlobalNetwork", 
            path: "/global-networks/{GlobalNetworkId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing global network. You must first delete all global network objects (devices, links, and sites), deregister all transit gateways, and delete any core networks.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGlobalNetwork(
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGlobalNetworkResponse {
        let input = DeleteGlobalNetworkRequest(
            globalNetworkId: globalNetworkId
        )
        return try await self.deleteGlobalNetwork(input, logger: logger)
    }

    /// Deletes an existing link. You must first disassociate the link from any devices and customer gateways.
    @Sendable
    @inlinable
    public func deleteLink(_ input: DeleteLinkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLinkResponse {
        try await self.client.execute(
            operation: "DeleteLink", 
            path: "/global-networks/{GlobalNetworkId}/links/{LinkId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing link. You must first disassociate the link from any devices and customer gateways.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLink(
        globalNetworkId: String,
        linkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLinkResponse {
        let input = DeleteLinkRequest(
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.deleteLink(input, logger: logger)
    }

    /// Deletes an existing peering connection.
    @Sendable
    @inlinable
    public func deletePeering(_ input: DeletePeeringRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePeeringResponse {
        try await self.client.execute(
            operation: "DeletePeering", 
            path: "/peerings/{PeeringId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing peering connection.
    ///
    /// Parameters:
    ///   - peeringId: The ID of the peering connection to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePeering(
        peeringId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePeeringResponse {
        let input = DeletePeeringRequest(
            peeringId: peeringId
        )
        return try await self.deletePeering(input, logger: logger)
    }

    /// Deletes a resource policy for the specified resource. This revokes the access of the principals specified in the resource policy.
    @Sendable
    @inlinable
    public func deleteResourcePolicy(_ input: DeleteResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourcePolicyResponse {
        try await self.client.execute(
            operation: "DeleteResourcePolicy", 
            path: "/resource-policy/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a resource policy for the specified resource. This revokes the access of the principals specified in the resource policy.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the policy to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourcePolicyResponse {
        let input = DeleteResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.deleteResourcePolicy(input, logger: logger)
    }

    /// Deletes an existing site. The site cannot be associated with any device or link.
    @Sendable
    @inlinable
    public func deleteSite(_ input: DeleteSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSiteResponse {
        try await self.client.execute(
            operation: "DeleteSite", 
            path: "/global-networks/{GlobalNetworkId}/sites/{SiteId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing site. The site cannot be associated with any device or link.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - siteId: The ID of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSite(
        globalNetworkId: String,
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSiteResponse {
        let input = DeleteSiteRequest(
            globalNetworkId: globalNetworkId, 
            siteId: siteId
        )
        return try await self.deleteSite(input, logger: logger)
    }

    /// Deregisters a transit gateway from your global network. This action does not delete your transit gateway, or modify any of its attachments. This action removes any customer gateway associations.
    @Sendable
    @inlinable
    public func deregisterTransitGateway(_ input: DeregisterTransitGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterTransitGatewayResponse {
        try await self.client.execute(
            operation: "DeregisterTransitGateway", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-registrations/{TransitGatewayArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregisters a transit gateway from your global network. This action does not delete your transit gateway, or modify any of its attachments. This action removes any customer gateway associations.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - transitGatewayArn: The Amazon Resource Name (ARN) of the transit gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterTransitGateway(
        globalNetworkId: String,
        transitGatewayArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterTransitGatewayResponse {
        let input = DeregisterTransitGatewayRequest(
            globalNetworkId: globalNetworkId, 
            transitGatewayArn: transitGatewayArn
        )
        return try await self.deregisterTransitGateway(input, logger: logger)
    }

    /// Describes one or more global networks. By default, all global networks are described. To describe the objects in your global network, you must use the appropriate Get* action. For example, to list the transit gateways in your global network, use GetTransitGatewayRegistrations.
    @Sendable
    @inlinable
    public func describeGlobalNetworks(_ input: DescribeGlobalNetworksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeGlobalNetworksResponse {
        try await self.client.execute(
            operation: "DescribeGlobalNetworks", 
            path: "/global-networks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes one or more global networks. By default, all global networks are described. To describe the objects in your global network, you must use the appropriate Get* action. For example, to list the transit gateways in your global network, use GetTransitGatewayRegistrations.
    ///
    /// Parameters:
    ///   - globalNetworkIds: The IDs of one or more global networks. The maximum is 10.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeGlobalNetworks(
        globalNetworkIds: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeGlobalNetworksResponse {
        let input = DescribeGlobalNetworksRequest(
            globalNetworkIds: globalNetworkIds, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeGlobalNetworks(input, logger: logger)
    }

    /// Disassociates a core network Connect peer from a device and a link.
    @Sendable
    @inlinable
    public func disassociateConnectPeer(_ input: DisassociateConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateConnectPeerResponse {
        try await self.client.execute(
            operation: "DisassociateConnectPeer", 
            path: "/global-networks/{GlobalNetworkId}/connect-peer-associations/{ConnectPeerId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a core network Connect peer from a device and a link.
    ///
    /// Parameters:
    ///   - connectPeerId: The ID of the Connect peer to disassociate from a device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateConnectPeer(
        connectPeerId: String,
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateConnectPeerResponse {
        let input = DisassociateConnectPeerRequest(
            connectPeerId: connectPeerId, 
            globalNetworkId: globalNetworkId
        )
        return try await self.disassociateConnectPeer(input, logger: logger)
    }

    /// Disassociates a customer gateway from a device and a link.
    @Sendable
    @inlinable
    public func disassociateCustomerGateway(_ input: DisassociateCustomerGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateCustomerGatewayResponse {
        try await self.client.execute(
            operation: "DisassociateCustomerGateway", 
            path: "/global-networks/{GlobalNetworkId}/customer-gateway-associations/{CustomerGatewayArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a customer gateway from a device and a link.
    ///
    /// Parameters:
    ///   - customerGatewayArn: The Amazon Resource Name (ARN) of the customer gateway.
    ///   - globalNetworkId: The ID of the global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateCustomerGateway(
        customerGatewayArn: String,
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateCustomerGatewayResponse {
        let input = DisassociateCustomerGatewayRequest(
            customerGatewayArn: customerGatewayArn, 
            globalNetworkId: globalNetworkId
        )
        return try await self.disassociateCustomerGateway(input, logger: logger)
    }

    /// Disassociates an existing device from a link. You must first disassociate any customer gateways that are associated with the link.
    @Sendable
    @inlinable
    public func disassociateLink(_ input: DisassociateLinkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateLinkResponse {
        try await self.client.execute(
            operation: "DisassociateLink", 
            path: "/global-networks/{GlobalNetworkId}/link-associations", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates an existing device from a link. You must first disassociate any customer gateways that are associated with the link.
    ///
    /// Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateLink(
        deviceId: String,
        globalNetworkId: String,
        linkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateLinkResponse {
        let input = DisassociateLinkRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.disassociateLink(input, logger: logger)
    }

    /// Disassociates a transit gateway Connect peer from a device and link.
    @Sendable
    @inlinable
    public func disassociateTransitGatewayConnectPeer(_ input: DisassociateTransitGatewayConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateTransitGatewayConnectPeerResponse {
        try await self.client.execute(
            operation: "DisassociateTransitGatewayConnectPeer", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations/{TransitGatewayConnectPeerArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a transit gateway Connect peer from a device and link.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - transitGatewayConnectPeerArn: The Amazon Resource Name (ARN) of the transit gateway Connect peer.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateTransitGatewayConnectPeer(
        globalNetworkId: String,
        transitGatewayConnectPeerArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateTransitGatewayConnectPeerResponse {
        let input = DisassociateTransitGatewayConnectPeerRequest(
            globalNetworkId: globalNetworkId, 
            transitGatewayConnectPeerArn: transitGatewayConnectPeerArn
        )
        return try await self.disassociateTransitGatewayConnectPeer(input, logger: logger)
    }

    /// Executes a change set on your core network. Deploys changes globally based on the policy submitted..
    @Sendable
    @inlinable
    public func executeCoreNetworkChangeSet(_ input: ExecuteCoreNetworkChangeSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ExecuteCoreNetworkChangeSetResponse {
        try await self.client.execute(
            operation: "ExecuteCoreNetworkChangeSet", 
            path: "/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}/execute", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Executes a change set on your core network. Deploys changes globally based on the policy submitted..
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - policyVersionId: The ID of the policy version.
    ///   - logger: Logger use during operation
    @inlinable
    public func executeCoreNetworkChangeSet(
        coreNetworkId: String,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ExecuteCoreNetworkChangeSetResponse {
        let input = ExecuteCoreNetworkChangeSetRequest(
            coreNetworkId: coreNetworkId, 
            policyVersionId: policyVersionId
        )
        return try await self.executeCoreNetworkChangeSet(input, logger: logger)
    }

    /// Returns information about a core network Connect attachment.
    @Sendable
    @inlinable
    public func getConnectAttachment(_ input: GetConnectAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectAttachmentResponse {
        try await self.client.execute(
            operation: "GetConnectAttachment", 
            path: "/connect-attachments/{AttachmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a core network Connect attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectAttachmentResponse {
        let input = GetConnectAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.getConnectAttachment(input, logger: logger)
    }

    /// Returns information about a core network Connect peer.
    @Sendable
    @inlinable
    public func getConnectPeer(_ input: GetConnectPeerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectPeerResponse {
        try await self.client.execute(
            operation: "GetConnectPeer", 
            path: "/connect-peers/{ConnectPeerId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a core network Connect peer.
    ///
    /// Parameters:
    ///   - connectPeerId: The ID of the Connect peer.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectPeer(
        connectPeerId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectPeerResponse {
        let input = GetConnectPeerRequest(
            connectPeerId: connectPeerId
        )
        return try await self.getConnectPeer(input, logger: logger)
    }

    /// Returns information about a core network Connect peer associations.
    @Sendable
    @inlinable
    public func getConnectPeerAssociations(_ input: GetConnectPeerAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectPeerAssociationsResponse {
        try await self.client.execute(
            operation: "GetConnectPeerAssociations", 
            path: "/global-networks/{GlobalNetworkId}/connect-peer-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a core network Connect peer associations.
    ///
    /// Parameters:
    ///   - connectPeerIds: The IDs of the Connect peers.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectPeerAssociations(
        connectPeerIds: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectPeerAssociationsResponse {
        let input = GetConnectPeerAssociationsRequest(
            connectPeerIds: connectPeerIds, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getConnectPeerAssociations(input, logger: logger)
    }

    /// Gets information about one or more of your connections in a global network.
    @Sendable
    @inlinable
    public func getConnections(_ input: GetConnectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectionsResponse {
        try await self.client.execute(
            operation: "GetConnections", 
            path: "/global-networks/{GlobalNetworkId}/connections", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more of your connections in a global network.
    ///
    /// Parameters:
    ///   - connectionIds: One or more connection IDs.
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnections(
        connectionIds: [String]? = nil,
        deviceId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectionsResponse {
        let input = GetConnectionsRequest(
            connectionIds: connectionIds, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getConnections(input, logger: logger)
    }

    /// Returns information about the LIVE policy for a core network.
    @Sendable
    @inlinable
    public func getCoreNetwork(_ input: GetCoreNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCoreNetworkResponse {
        try await self.client.execute(
            operation: "GetCoreNetwork", 
            path: "/core-networks/{CoreNetworkId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the LIVE policy for a core network.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreNetwork(
        coreNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreNetworkResponse {
        let input = GetCoreNetworkRequest(
            coreNetworkId: coreNetworkId
        )
        return try await self.getCoreNetwork(input, logger: logger)
    }

    /// Returns information about a core network change event.
    @Sendable
    @inlinable
    public func getCoreNetworkChangeEvents(_ input: GetCoreNetworkChangeEventsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCoreNetworkChangeEventsResponse {
        try await self.client.execute(
            operation: "GetCoreNetworkChangeEvents", 
            path: "/core-networks/{CoreNetworkId}/core-network-change-events/{PolicyVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a core network change event.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - policyVersionId: The ID of the policy version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreNetworkChangeEvents(
        coreNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreNetworkChangeEventsResponse {
        let input = GetCoreNetworkChangeEventsRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            policyVersionId: policyVersionId
        )
        return try await self.getCoreNetworkChangeEvents(input, logger: logger)
    }

    /// Returns a change set between the LIVE core network policy and a submitted policy.
    @Sendable
    @inlinable
    public func getCoreNetworkChangeSet(_ input: GetCoreNetworkChangeSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCoreNetworkChangeSetResponse {
        try await self.client.execute(
            operation: "GetCoreNetworkChangeSet", 
            path: "/core-networks/{CoreNetworkId}/core-network-change-sets/{PolicyVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a change set between the LIVE core network policy and a submitted policy.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - policyVersionId: The ID of the policy version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreNetworkChangeSet(
        coreNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreNetworkChangeSetResponse {
        let input = GetCoreNetworkChangeSetRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            policyVersionId: policyVersionId
        )
        return try await self.getCoreNetworkChangeSet(input, logger: logger)
    }

    /// Returns details about a core network policy. You can get details about your current live policy or any previous policy version.
    @Sendable
    @inlinable
    public func getCoreNetworkPolicy(_ input: GetCoreNetworkPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCoreNetworkPolicyResponse {
        try await self.client.execute(
            operation: "GetCoreNetworkPolicy", 
            path: "/core-networks/{CoreNetworkId}/core-network-policy", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns details about a core network policy. You can get details about your current live policy or any previous policy version.
    ///
    /// Parameters:
    ///   - alias: The alias of a core network policy
    ///   - coreNetworkId: The ID of a core network.
    ///   - policyVersionId: The ID of a core network policy version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreNetworkPolicy(
        alias: CoreNetworkPolicyAlias? = nil,
        coreNetworkId: String,
        policyVersionId: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreNetworkPolicyResponse {
        let input = GetCoreNetworkPolicyRequest(
            alias: alias, 
            coreNetworkId: coreNetworkId, 
            policyVersionId: policyVersionId
        )
        return try await self.getCoreNetworkPolicy(input, logger: logger)
    }

    /// Gets the association information for customer gateways that are associated with devices and links in your global network.
    @Sendable
    @inlinable
    public func getCustomerGatewayAssociations(_ input: GetCustomerGatewayAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCustomerGatewayAssociationsResponse {
        try await self.client.execute(
            operation: "GetCustomerGatewayAssociations", 
            path: "/global-networks/{GlobalNetworkId}/customer-gateway-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the association information for customer gateways that are associated with devices and links in your global network.
    ///
    /// Parameters:
    ///   - customerGatewayArns: One or more customer gateway Amazon Resource Names (ARNs). The maximum is 10.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCustomerGatewayAssociations(
        customerGatewayArns: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCustomerGatewayAssociationsResponse {
        let input = GetCustomerGatewayAssociationsRequest(
            customerGatewayArns: customerGatewayArns, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getCustomerGatewayAssociations(input, logger: logger)
    }

    /// Gets information about one or more of your devices in a global network.
    @Sendable
    @inlinable
    public func getDevices(_ input: GetDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDevicesResponse {
        try await self.client.execute(
            operation: "GetDevices", 
            path: "/global-networks/{GlobalNetworkId}/devices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more of your devices in a global network.
    ///
    /// Parameters:
    ///   - deviceIds: One or more device IDs. The maximum is 10.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - siteId: The ID of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevices(
        deviceIds: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        siteId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDevicesResponse {
        let input = GetDevicesRequest(
            deviceIds: deviceIds, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            siteId: siteId
        )
        return try await self.getDevices(input, logger: logger)
    }

    /// Returns information about a specific Amazon Web Services Direct Connect gateway attachment.
    @Sendable
    @inlinable
    public func getDirectConnectGatewayAttachment(_ input: GetDirectConnectGatewayAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDirectConnectGatewayAttachmentResponse {
        try await self.client.execute(
            operation: "GetDirectConnectGatewayAttachment", 
            path: "/direct-connect-gateway-attachments/{AttachmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a specific Amazon Web Services Direct Connect gateway attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the Direct Connect gateway attachment that you want to see details about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDirectConnectGatewayAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDirectConnectGatewayAttachmentResponse {
        let input = GetDirectConnectGatewayAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.getDirectConnectGatewayAttachment(input, logger: logger)
    }

    /// Gets the link associations for a device or a link. Either the device ID or the link ID must be specified.
    @Sendable
    @inlinable
    public func getLinkAssociations(_ input: GetLinkAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLinkAssociationsResponse {
        try await self.client.execute(
            operation: "GetLinkAssociations", 
            path: "/global-networks/{GlobalNetworkId}/link-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the link associations for a device or a link. Either the device ID or the link ID must be specified.
    ///
    /// Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLinkAssociations(
        deviceId: String? = nil,
        globalNetworkId: String,
        linkId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLinkAssociationsResponse {
        let input = GetLinkAssociationsRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getLinkAssociations(input, logger: logger)
    }

    /// Gets information about one or more links in a specified global network. If you specify the site ID, you cannot specify the type or provider in the same request. You can specify the type and provider in the same request.
    @Sendable
    @inlinable
    public func getLinks(_ input: GetLinksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLinksResponse {
        try await self.client.execute(
            operation: "GetLinks", 
            path: "/global-networks/{GlobalNetworkId}/links", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more links in a specified global network. If you specify the site ID, you cannot specify the type or provider in the same request. You can specify the type and provider in the same request.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkIds: One or more link IDs. The maximum is 10.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - provider: The link provider.
    ///   - siteId: The ID of the site.
    ///   - type: The link type.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLinks(
        globalNetworkId: String,
        linkIds: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        provider: String? = nil,
        siteId: String? = nil,
        type: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLinksResponse {
        let input = GetLinksRequest(
            globalNetworkId: globalNetworkId, 
            linkIds: linkIds, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            provider: provider, 
            siteId: siteId, 
            type: type
        )
        return try await self.getLinks(input, logger: logger)
    }

    /// Gets the count of network resources, by resource type, for the specified global network.
    @Sendable
    @inlinable
    public func getNetworkResourceCounts(_ input: GetNetworkResourceCountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkResourceCountsResponse {
        try await self.client.execute(
            operation: "GetNetworkResourceCounts", 
            path: "/global-networks/{GlobalNetworkId}/network-resource-count", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the count of network resources, by resource type, for the specified global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkResourceCounts(
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkResourceCountsResponse {
        let input = GetNetworkResourceCountsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.getNetworkResourceCounts(input, logger: logger)
    }

    /// Gets the network resource relationships for the specified global network.
    @Sendable
    @inlinable
    public func getNetworkResourceRelationships(_ input: GetNetworkResourceRelationshipsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkResourceRelationshipsResponse {
        try await self.client.execute(
            operation: "GetNetworkResourceRelationships", 
            path: "/global-networks/{GlobalNetworkId}/network-resource-relationships", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the network resource relationships for the specified global network.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - registeredGatewayArn: The ARN of the registered gateway.
    ///   - resourceArn: The ARN of the gateway.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkResourceRelationships(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkResourceRelationshipsResponse {
        let input = GetNetworkResourceRelationshipsRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return try await self.getNetworkResourceRelationships(input, logger: logger)
    }

    /// Describes the network resources for the specified global network. The results include information from the corresponding Describe call for the resource, minus any sensitive information such as pre-shared keys.
    @Sendable
    @inlinable
    public func getNetworkResources(_ input: GetNetworkResourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkResourcesResponse {
        try await self.client.execute(
            operation: "GetNetworkResources", 
            path: "/global-networks/{GlobalNetworkId}/network-resources", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the network resources for the specified global network. The results include information from the corresponding Describe call for the resource, minus any sensitive information such as pre-shared keys.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - registeredGatewayArn: The ARN of the gateway.
    ///   - resourceArn: The ARN of the resource.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkResources(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkResourcesResponse {
        let input = GetNetworkResourcesRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return try await self.getNetworkResources(input, logger: logger)
    }

    /// Gets the network routes of the specified global network.
    @Sendable
    @inlinable
    public func getNetworkRoutes(_ input: GetNetworkRoutesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkRoutesResponse {
        try await self.client.execute(
            operation: "GetNetworkRoutes", 
            path: "/global-networks/{GlobalNetworkId}/network-routes", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the network routes of the specified global network.
    ///
    /// Parameters:
    ///   - destinationFilters: Filter by route table destination. Possible Values: TRANSIT_GATEWAY_ATTACHMENT_ID, RESOURCE_ID, or RESOURCE_TYPE.
    ///   - exactCidrMatches: An exact CIDR block.
    ///   - globalNetworkId: The ID of the global network.
    ///   - longestPrefixMatches: The most specific route that matches the traffic (longest prefix match).
    ///   - prefixListIds: The IDs of the prefix lists.
    ///   - routeTableIdentifier: The ID of the route table.
    ///   - states: The route states.
    ///   - subnetOfMatches: The routes with a subnet that match the specified CIDR filter.
    ///   - supernetOfMatches: The routes with a CIDR that encompasses the CIDR filter. Example: If you specify 10.0.1.0/30, then the result returns 10.0.1.0/29.
    ///   - types: The route types.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkRoutes(
        destinationFilters: [String: [String]]? = nil,
        exactCidrMatches: [String]? = nil,
        globalNetworkId: String,
        longestPrefixMatches: [String]? = nil,
        prefixListIds: [String]? = nil,
        routeTableIdentifier: RouteTableIdentifier,
        states: [RouteState]? = nil,
        subnetOfMatches: [String]? = nil,
        supernetOfMatches: [String]? = nil,
        types: [RouteType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkRoutesResponse {
        let input = GetNetworkRoutesRequest(
            destinationFilters: destinationFilters, 
            exactCidrMatches: exactCidrMatches, 
            globalNetworkId: globalNetworkId, 
            longestPrefixMatches: longestPrefixMatches, 
            prefixListIds: prefixListIds, 
            routeTableIdentifier: routeTableIdentifier, 
            states: states, 
            subnetOfMatches: subnetOfMatches, 
            supernetOfMatches: supernetOfMatches, 
            types: types
        )
        return try await self.getNetworkRoutes(input, logger: logger)
    }

    /// Gets the network telemetry of the specified global network.
    @Sendable
    @inlinable
    public func getNetworkTelemetry(_ input: GetNetworkTelemetryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNetworkTelemetryResponse {
        try await self.client.execute(
            operation: "GetNetworkTelemetry", 
            path: "/global-networks/{GlobalNetworkId}/network-telemetry", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the network telemetry of the specified global network.
    ///
    /// Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - registeredGatewayArn: The ARN of the gateway.
    ///   - resourceArn: The ARN of the resource.
    ///   - resourceType: The resource type. The following are the supported resource types:    connect-peer     transit-gateway-connect-peer     vpn-connection
    ///   - logger: Logger use during operation
    @inlinable
    public func getNetworkTelemetry(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNetworkTelemetryResponse {
        let input = GetNetworkTelemetryRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return try await self.getNetworkTelemetry(input, logger: logger)
    }

    /// Returns information about a resource policy.
    @Sendable
    @inlinable
    public func getResourcePolicy(_ input: GetResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourcePolicyResponse {
        try await self.client.execute(
            operation: "GetResourcePolicy", 
            path: "/resource-policy/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a resource policy.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourcePolicyResponse {
        let input = GetResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.getResourcePolicy(input, logger: logger)
    }

    /// Gets information about the specified route analysis.
    @Sendable
    @inlinable
    public func getRouteAnalysis(_ input: GetRouteAnalysisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRouteAnalysisResponse {
        try await self.client.execute(
            operation: "GetRouteAnalysis", 
            path: "/global-networks/{GlobalNetworkId}/route-analyses/{RouteAnalysisId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified route analysis.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - routeAnalysisId: The ID of the route analysis.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRouteAnalysis(
        globalNetworkId: String,
        routeAnalysisId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRouteAnalysisResponse {
        let input = GetRouteAnalysisRequest(
            globalNetworkId: globalNetworkId, 
            routeAnalysisId: routeAnalysisId
        )
        return try await self.getRouteAnalysis(input, logger: logger)
    }

    /// Returns information about a site-to-site VPN attachment.
    @Sendable
    @inlinable
    public func getSiteToSiteVpnAttachment(_ input: GetSiteToSiteVpnAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSiteToSiteVpnAttachmentResponse {
        try await self.client.execute(
            operation: "GetSiteToSiteVpnAttachment", 
            path: "/site-to-site-vpn-attachments/{AttachmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a site-to-site VPN attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSiteToSiteVpnAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSiteToSiteVpnAttachmentResponse {
        let input = GetSiteToSiteVpnAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.getSiteToSiteVpnAttachment(input, logger: logger)
    }

    /// Gets information about one or more of your sites in a global network.
    @Sendable
    @inlinable
    public func getSites(_ input: GetSitesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSitesResponse {
        try await self.client.execute(
            operation: "GetSites", 
            path: "/global-networks/{GlobalNetworkId}/sites", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more of your sites in a global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - siteIds: One or more site IDs. The maximum is 10.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSites(
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        siteIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSitesResponse {
        let input = GetSitesRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            siteIds: siteIds
        )
        return try await self.getSites(input, logger: logger)
    }

    /// Gets information about one or more of your transit gateway Connect peer associations in a global network.
    @Sendable
    @inlinable
    public func getTransitGatewayConnectPeerAssociations(_ input: GetTransitGatewayConnectPeerAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTransitGatewayConnectPeerAssociationsResponse {
        try await self.client.execute(
            operation: "GetTransitGatewayConnectPeerAssociations", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-connect-peer-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about one or more of your transit gateway Connect peer associations in a global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - transitGatewayConnectPeerArns: One or more transit gateway Connect peer Amazon Resource Names (ARNs).
    ///   - logger: Logger use during operation
    @inlinable
    public func getTransitGatewayConnectPeerAssociations(
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        transitGatewayConnectPeerArns: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTransitGatewayConnectPeerAssociationsResponse {
        let input = GetTransitGatewayConnectPeerAssociationsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            transitGatewayConnectPeerArns: transitGatewayConnectPeerArns
        )
        return try await self.getTransitGatewayConnectPeerAssociations(input, logger: logger)
    }

    /// Returns information about a transit gateway peer.
    @Sendable
    @inlinable
    public func getTransitGatewayPeering(_ input: GetTransitGatewayPeeringRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTransitGatewayPeeringResponse {
        try await self.client.execute(
            operation: "GetTransitGatewayPeering", 
            path: "/transit-gateway-peerings/{PeeringId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a transit gateway peer.
    ///
    /// Parameters:
    ///   - peeringId: The ID of the peering request.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTransitGatewayPeering(
        peeringId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTransitGatewayPeeringResponse {
        let input = GetTransitGatewayPeeringRequest(
            peeringId: peeringId
        )
        return try await self.getTransitGatewayPeering(input, logger: logger)
    }

    /// Gets information about the transit gateway registrations in a specified global network.
    @Sendable
    @inlinable
    public func getTransitGatewayRegistrations(_ input: GetTransitGatewayRegistrationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTransitGatewayRegistrationsResponse {
        try await self.client.execute(
            operation: "GetTransitGatewayRegistrations", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-registrations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the transit gateway registrations in a specified global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - transitGatewayArns: The Amazon Resource Names (ARNs) of one or more transit gateways. The maximum is 10.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTransitGatewayRegistrations(
        globalNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        transitGatewayArns: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTransitGatewayRegistrationsResponse {
        let input = GetTransitGatewayRegistrationsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            transitGatewayArns: transitGatewayArns
        )
        return try await self.getTransitGatewayRegistrations(input, logger: logger)
    }

    /// Returns information about a transit gateway route table attachment.
    @Sendable
    @inlinable
    public func getTransitGatewayRouteTableAttachment(_ input: GetTransitGatewayRouteTableAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTransitGatewayRouteTableAttachmentResponse {
        try await self.client.execute(
            operation: "GetTransitGatewayRouteTableAttachment", 
            path: "/transit-gateway-route-table-attachments/{AttachmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a transit gateway route table attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the transit gateway route table attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTransitGatewayRouteTableAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTransitGatewayRouteTableAttachmentResponse {
        let input = GetTransitGatewayRouteTableAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.getTransitGatewayRouteTableAttachment(input, logger: logger)
    }

    /// Returns information about a VPC attachment.
    @Sendable
    @inlinable
    public func getVpcAttachment(_ input: GetVpcAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVpcAttachmentResponse {
        try await self.client.execute(
            operation: "GetVpcAttachment", 
            path: "/vpc-attachments/{AttachmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a VPC attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVpcAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVpcAttachmentResponse {
        let input = GetVpcAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.getVpcAttachment(input, logger: logger)
    }

    /// Returns a list of core network attachments.
    @Sendable
    @inlinable
    public func listAttachments(_ input: ListAttachmentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAttachmentsResponse {
        try await self.client.execute(
            operation: "ListAttachments", 
            path: "/attachments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of core network attachments.
    ///
    /// Parameters:
    ///   - attachmentType: The type of attachment.
    ///   - coreNetworkId: The ID of a core network.
    ///   - edgeLocation: The Region where the edge is located.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - state: The state of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAttachments(
        attachmentType: AttachmentType? = nil,
        coreNetworkId: String? = nil,
        edgeLocation: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        state: AttachmentState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAttachmentsResponse {
        let input = ListAttachmentsRequest(
            attachmentType: attachmentType, 
            coreNetworkId: coreNetworkId, 
            edgeLocation: edgeLocation, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            state: state
        )
        return try await self.listAttachments(input, logger: logger)
    }

    /// Returns a list of core network Connect peers.
    @Sendable
    @inlinable
    public func listConnectPeers(_ input: ListConnectPeersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConnectPeersResponse {
        try await self.client.execute(
            operation: "ListConnectPeers", 
            path: "/connect-peers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of core network Connect peers.
    ///
    /// Parameters:
    ///   - connectAttachmentId: The ID of the attachment.
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConnectPeers(
        connectAttachmentId: String? = nil,
        coreNetworkId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConnectPeersResponse {
        let input = ListConnectPeersRequest(
            connectAttachmentId: connectAttachmentId, 
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConnectPeers(input, logger: logger)
    }

    /// Returns a list of core network policy versions.
    @Sendable
    @inlinable
    public func listCoreNetworkPolicyVersions(_ input: ListCoreNetworkPolicyVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCoreNetworkPolicyVersionsResponse {
        try await self.client.execute(
            operation: "ListCoreNetworkPolicyVersions", 
            path: "/core-networks/{CoreNetworkId}/core-network-policy-versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of core network policy versions.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoreNetworkPolicyVersions(
        coreNetworkId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoreNetworkPolicyVersionsResponse {
        let input = ListCoreNetworkPolicyVersionsRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCoreNetworkPolicyVersions(input, logger: logger)
    }

    /// Returns a list of owned and shared core networks.
    @Sendable
    @inlinable
    public func listCoreNetworks(_ input: ListCoreNetworksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCoreNetworksResponse {
        try await self.client.execute(
            operation: "ListCoreNetworks", 
            path: "/core-networks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of owned and shared core networks.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoreNetworks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoreNetworksResponse {
        let input = ListCoreNetworksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCoreNetworks(input, logger: logger)
    }

    /// Gets the status of the Service Linked Role (SLR) deployment for the accounts in a given Amazon Web Services Organization.
    @Sendable
    @inlinable
    public func listOrganizationServiceAccessStatus(_ input: ListOrganizationServiceAccessStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOrganizationServiceAccessStatusResponse {
        try await self.client.execute(
            operation: "ListOrganizationServiceAccessStatus", 
            path: "/organizations/service-access", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the status of the Service Linked Role (SLR) deployment for the accounts in a given Amazon Web Services Organization.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOrganizationServiceAccessStatus(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOrganizationServiceAccessStatusResponse {
        let input = ListOrganizationServiceAccessStatusRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOrganizationServiceAccessStatus(input, logger: logger)
    }

    /// Lists the peerings for a core network.
    @Sendable
    @inlinable
    public func listPeerings(_ input: ListPeeringsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPeeringsResponse {
        try await self.client.execute(
            operation: "ListPeerings", 
            path: "/peerings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the peerings for a core network.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - edgeLocation: Returns a list edge locations for the
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: The token for the next page of results.
    ///   - peeringType: Returns a list of a peering requests.
    ///   - state: Returns a list of the peering request states.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPeerings(
        coreNetworkId: String? = nil,
        edgeLocation: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        peeringType: PeeringType? = nil,
        state: PeeringState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPeeringsResponse {
        let input = ListPeeringsRequest(
            coreNetworkId: coreNetworkId, 
            edgeLocation: edgeLocation, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            peeringType: peeringType, 
            state: state
        )
        return try await self.listPeerings(input, logger: logger)
    }

    /// Lists the tags for a specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for a specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Creates a new, immutable version of a core network policy. A subsequent change set is created showing the differences between the LIVE policy and the submitted policy.
    @Sendable
    @inlinable
    public func putCoreNetworkPolicy(_ input: PutCoreNetworkPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutCoreNetworkPolicyResponse {
        try await self.client.execute(
            operation: "PutCoreNetworkPolicy", 
            path: "/core-networks/{CoreNetworkId}/core-network-policy", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new, immutable version of a core network policy. A subsequent change set is created showing the differences between the LIVE policy and the submitted policy.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the request.
    ///   - coreNetworkId: The ID of a core network.
    ///   - description: a core network policy description.
    ///   - latestVersionId: The ID of a core network policy.
    ///   - policyDocument: The policy document.
    ///   - logger: Logger use during operation
    @inlinable
    public func putCoreNetworkPolicy(
        clientToken: String? = PutCoreNetworkPolicyRequest.idempotencyToken(),
        coreNetworkId: String,
        description: String? = nil,
        latestVersionId: Int? = nil,
        policyDocument: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutCoreNetworkPolicyResponse {
        let input = PutCoreNetworkPolicyRequest(
            clientToken: clientToken, 
            coreNetworkId: coreNetworkId, 
            description: description, 
            latestVersionId: latestVersionId, 
            policyDocument: policyDocument
        )
        return try await self.putCoreNetworkPolicy(input, logger: logger)
    }

    /// Creates or updates a resource policy.
    @Sendable
    @inlinable
    public func putResourcePolicy(_ input: PutResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutResourcePolicyResponse {
        try await self.client.execute(
            operation: "PutResourcePolicy", 
            path: "/resource-policy/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates or updates a resource policy.
    ///
    /// Parameters:
    ///   - policyDocument: The JSON resource policy document.
    ///   - resourceArn: The ARN of the resource policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func putResourcePolicy(
        policyDocument: String,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutResourcePolicyResponse {
        let input = PutResourcePolicyRequest(
            policyDocument: policyDocument, 
            resourceArn: resourceArn
        )
        return try await self.putResourcePolicy(input, logger: logger)
    }

    /// Registers a transit gateway in your global network. Not all Regions support transit gateways for global networks. For a list of the supported Regions, see Region Availability in the Amazon Web Services Transit Gateways for Global Networks User Guide. The transit gateway can be in any of the supported Amazon Web Services Regions, but it must be owned by the same Amazon Web Services account that owns the global network. You cannot register a transit gateway in more than one global network.
    @Sendable
    @inlinable
    public func registerTransitGateway(_ input: RegisterTransitGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterTransitGatewayResponse {
        try await self.client.execute(
            operation: "RegisterTransitGateway", 
            path: "/global-networks/{GlobalNetworkId}/transit-gateway-registrations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Registers a transit gateway in your global network. Not all Regions support transit gateways for global networks. For a list of the supported Regions, see Region Availability in the Amazon Web Services Transit Gateways for Global Networks User Guide. The transit gateway can be in any of the supported Amazon Web Services Regions, but it must be owned by the same Amazon Web Services account that owns the global network. You cannot register a transit gateway in more than one global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - transitGatewayArn: The Amazon Resource Name (ARN) of the transit gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerTransitGateway(
        globalNetworkId: String,
        transitGatewayArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterTransitGatewayResponse {
        let input = RegisterTransitGatewayRequest(
            globalNetworkId: globalNetworkId, 
            transitGatewayArn: transitGatewayArn
        )
        return try await self.registerTransitGateway(input, logger: logger)
    }

    /// Rejects a core network attachment request.
    @Sendable
    @inlinable
    public func rejectAttachment(_ input: RejectAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RejectAttachmentResponse {
        try await self.client.execute(
            operation: "RejectAttachment", 
            path: "/attachments/{AttachmentId}/reject", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Rejects a core network attachment request.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func rejectAttachment(
        attachmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RejectAttachmentResponse {
        let input = RejectAttachmentRequest(
            attachmentId: attachmentId
        )
        return try await self.rejectAttachment(input, logger: logger)
    }

    /// Restores a previous policy version as a new, immutable version of a core network policy. A subsequent change set is created showing the differences between the LIVE policy and restored policy.
    @Sendable
    @inlinable
    public func restoreCoreNetworkPolicyVersion(_ input: RestoreCoreNetworkPolicyVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RestoreCoreNetworkPolicyVersionResponse {
        try await self.client.execute(
            operation: "RestoreCoreNetworkPolicyVersion", 
            path: "/core-networks/{CoreNetworkId}/core-network-policy-versions/{PolicyVersionId}/restore", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Restores a previous policy version as a new, immutable version of a core network policy. A subsequent change set is created showing the differences between the LIVE policy and restored policy.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - policyVersionId: The ID of the policy version to restore.
    ///   - logger: Logger use during operation
    @inlinable
    public func restoreCoreNetworkPolicyVersion(
        coreNetworkId: String,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RestoreCoreNetworkPolicyVersionResponse {
        let input = RestoreCoreNetworkPolicyVersionRequest(
            coreNetworkId: coreNetworkId, 
            policyVersionId: policyVersionId
        )
        return try await self.restoreCoreNetworkPolicyVersion(input, logger: logger)
    }

    /// Enables the Network Manager service for an Amazon Web Services Organization. This can only be called by a management account within the organization.
    @Sendable
    @inlinable
    public func startOrganizationServiceAccessUpdate(_ input: StartOrganizationServiceAccessUpdateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartOrganizationServiceAccessUpdateResponse {
        try await self.client.execute(
            operation: "StartOrganizationServiceAccessUpdate", 
            path: "/organizations/service-access", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the Network Manager service for an Amazon Web Services Organization. This can only be called by a management account within the organization.
    ///
    /// Parameters:
    ///   - action: The action to take for the update request. This can be either ENABLE or DISABLE.
    ///   - logger: Logger use during operation
    @inlinable
    public func startOrganizationServiceAccessUpdate(
        action: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartOrganizationServiceAccessUpdateResponse {
        let input = StartOrganizationServiceAccessUpdateRequest(
            action: action
        )
        return try await self.startOrganizationServiceAccessUpdate(input, logger: logger)
    }

    /// Starts analyzing the routing path between the specified source and destination. For more information,  see Route Analyzer.
    @Sendable
    @inlinable
    public func startRouteAnalysis(_ input: StartRouteAnalysisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartRouteAnalysisResponse {
        try await self.client.execute(
            operation: "StartRouteAnalysis", 
            path: "/global-networks/{GlobalNetworkId}/route-analyses", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts analyzing the routing path between the specified source and destination. For more information,  see Route Analyzer.
    ///
    /// Parameters:
    ///   - destination: The destination.
    ///   - globalNetworkId: The ID of the global network.
    ///   - includeReturnPath: Indicates whether to analyze the return path. The default is false.
    ///   - source: The source from which traffic originates.
    ///   - useMiddleboxes: Indicates whether to include the location of middlebox appliances in the route analysis. The default is false.
    ///   - logger: Logger use during operation
    @inlinable
    public func startRouteAnalysis(
        destination: RouteAnalysisEndpointOptionsSpecification,
        globalNetworkId: String,
        includeReturnPath: Bool? = nil,
        source: RouteAnalysisEndpointOptionsSpecification,
        useMiddleboxes: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartRouteAnalysisResponse {
        let input = StartRouteAnalysisRequest(
            destination: destination, 
            globalNetworkId: globalNetworkId, 
            includeReturnPath: includeReturnPath, 
            source: source, 
            useMiddleboxes: useMiddleboxes
        )
        return try await self.startRouteAnalysis(input, logger: logger)
    }

    /// Tags a specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tags a specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags to apply to the specified resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from a specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from a specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys to remove from the specified resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the information for an existing connection. To remove information for any of the parameters, specify an empty string.
    @Sendable
    @inlinable
    public func updateConnection(_ input: UpdateConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateConnectionResponse {
        try await self.client.execute(
            operation: "UpdateConnection", 
            path: "/global-networks/{GlobalNetworkId}/connections/{ConnectionId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the information for an existing connection. To remove information for any of the parameters, specify an empty string.
    ///
    /// Parameters:
    ///   - connectedLinkId: The ID of the link for the second device in the connection.
    ///   - connectionId: The ID of the connection.
    ///   - description: A description of the connection. Length Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link for the first device in the connection.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConnection(
        connectedLinkId: String? = nil,
        connectionId: String,
        description: String? = nil,
        globalNetworkId: String,
        linkId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConnectionResponse {
        let input = UpdateConnectionRequest(
            connectedLinkId: connectedLinkId, 
            connectionId: connectionId, 
            description: description, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId
        )
        return try await self.updateConnection(input, logger: logger)
    }

    /// Updates the description of a core network.
    @Sendable
    @inlinable
    public func updateCoreNetwork(_ input: UpdateCoreNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCoreNetworkResponse {
        try await self.client.execute(
            operation: "UpdateCoreNetwork", 
            path: "/core-networks/{CoreNetworkId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the description of a core network.
    ///
    /// Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - description: The description of the update.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCoreNetwork(
        coreNetworkId: String,
        description: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCoreNetworkResponse {
        let input = UpdateCoreNetworkRequest(
            coreNetworkId: coreNetworkId, 
            description: description
        )
        return try await self.updateCoreNetwork(input, logger: logger)
    }

    /// Updates the details for an existing device. To remove information for any of the parameters, specify an empty string.
    @Sendable
    @inlinable
    public func updateDevice(_ input: UpdateDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDeviceResponse {
        try await self.client.execute(
            operation: "UpdateDevice", 
            path: "/global-networks/{GlobalNetworkId}/devices/{DeviceId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the details for an existing device. To remove information for any of the parameters, specify an empty string.
    ///
    /// Parameters:
    ///   - awsLocation: The Amazon Web Services location of the device, if applicable. For an on-premises device, you can omit this parameter.
    ///   - description: A description of the device. Constraints: Maximum length of 256 characters.
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - location: 
    ///   - model: The model of the device. Constraints: Maximum length of 128 characters.
    ///   - serialNumber: The serial number of the device. Constraints: Maximum length of 128 characters.
    ///   - siteId: The ID of the site.
    ///   - type: The type of the device.
    ///   - vendor: The vendor of the device. Constraints: Maximum length of 128 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDevice(
        awsLocation: AWSLocation? = nil,
        description: String? = nil,
        deviceId: String,
        globalNetworkId: String,
        location: Location? = nil,
        model: String? = nil,
        serialNumber: String? = nil,
        siteId: String? = nil,
        type: String? = nil,
        vendor: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDeviceResponse {
        let input = UpdateDeviceRequest(
            awsLocation: awsLocation, 
            description: description, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            location: location, 
            model: model, 
            serialNumber: serialNumber, 
            siteId: siteId, 
            type: type, 
            vendor: vendor
        )
        return try await self.updateDevice(input, logger: logger)
    }

    /// Updates the edge locations associated with an Amazon Web Services Direct Connect gateway attachment.
    @Sendable
    @inlinable
    public func updateDirectConnectGatewayAttachment(_ input: UpdateDirectConnectGatewayAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateDirectConnectGatewayAttachmentResponse {
        try await self.client.execute(
            operation: "UpdateDirectConnectGatewayAttachment", 
            path: "/direct-connect-gateway-attachments/{AttachmentId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the edge locations associated with an Amazon Web Services Direct Connect gateway attachment.
    ///
    /// Parameters:
    ///   - attachmentId: The ID of the Direct Connect gateway attachment for the updated edge locations.
    ///   - edgeLocations: One or more edge locations to update for the Direct Connect gateway attachment. The updated array of edge locations overwrites the previous array of locations. EdgeLocations is only used for Direct Connect gateway attachments.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDirectConnectGatewayAttachment(
        attachmentId: String,
        edgeLocations: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDirectConnectGatewayAttachmentResponse {
        let input = UpdateDirectConnectGatewayAttachmentRequest(
            attachmentId: attachmentId, 
            edgeLocations: edgeLocations
        )
        return try await self.updateDirectConnectGatewayAttachment(input, logger: logger)
    }

    /// Updates an existing global network. To remove information for any of the parameters, specify an empty string.
    @Sendable
    @inlinable
    public func updateGlobalNetwork(_ input: UpdateGlobalNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateGlobalNetworkResponse {
        try await self.client.execute(
            operation: "UpdateGlobalNetwork", 
            path: "/global-networks/{GlobalNetworkId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing global network. To remove information for any of the parameters, specify an empty string.
    ///
    /// Parameters:
    ///   - description: A description of the global network. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of your global network.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGlobalNetwork(
        description: String? = nil,
        globalNetworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGlobalNetworkResponse {
        let input = UpdateGlobalNetworkRequest(
            description: description, 
            globalNetworkId: globalNetworkId
        )
        return try await self.updateGlobalNetwork(input, logger: logger)
    }

    /// Updates the details for an existing link. To remove information for any of the parameters, specify an empty string.
    @Sendable
    @inlinable
    public func updateLink(_ input: UpdateLinkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLinkResponse {
        try await self.client.execute(
            operation: "UpdateLink", 
            path: "/global-networks/{GlobalNetworkId}/links/{LinkId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the details for an existing link. To remove information for any of the parameters, specify an empty string.
    ///
    /// Parameters:
    ///   - bandwidth: The upload and download speed in Mbps.
    ///   - description: A description of the link. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - provider: The provider of the link. Constraints: Maximum length of 128 characters.
    ///   - type: The type of the link. Constraints: Maximum length of 128 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLink(
        bandwidth: Bandwidth? = nil,
        description: String? = nil,
        globalNetworkId: String,
        linkId: String,
        provider: String? = nil,
        type: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLinkResponse {
        let input = UpdateLinkRequest(
            bandwidth: bandwidth, 
            description: description, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId, 
            provider: provider, 
            type: type
        )
        return try await self.updateLink(input, logger: logger)
    }

    /// Updates the resource metadata for the specified global network.
    @Sendable
    @inlinable
    public func updateNetworkResourceMetadata(_ input: UpdateNetworkResourceMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNetworkResourceMetadataResponse {
        try await self.client.execute(
            operation: "UpdateNetworkResourceMetadata", 
            path: "/global-networks/{GlobalNetworkId}/network-resources/{ResourceArn}/metadata", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the resource metadata for the specified global network.
    ///
    /// Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - metadata: The resource metadata.
    ///   - resourceArn: The ARN of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNetworkResourceMetadata(
        globalNetworkId: String,
        metadata: [String: String],
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNetworkResourceMetadataResponse {
        let input = UpdateNetworkResourceMetadataRequest(
            globalNetworkId: globalNetworkId, 
            metadata: metadata, 
            resourceArn: resourceArn
        )
        return try await self.updateNetworkResourceMetadata(input, logger: logger)
    }

    /// Updates the information for an existing site. To remove information for any of the parameters, specify an empty string.
    @Sendable
    @inlinable
    public func updateSite(_ input: UpdateSiteRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSiteResponse {
        try await self.client.execute(
            operation: "UpdateSite", 
            path: "/global-networks/{GlobalNetworkId}/sites/{SiteId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the information for an existing site. To remove information for any of the parameters, specify an empty string.
    ///
    /// Parameters:
    ///   - description: A description of your site. Constraints: Maximum length of 256 characters.
    ///   - globalNetworkId: The ID of the global network.
    ///   - location: The site location:    Address: The physical address of the site.    Latitude: The latitude of the site.     Longitude: The longitude of the site.
    ///   - siteId: The ID of your site.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSite(
        description: String? = nil,
        globalNetworkId: String,
        location: Location? = nil,
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSiteResponse {
        let input = UpdateSiteRequest(
            description: description, 
            globalNetworkId: globalNetworkId, 
            location: location, 
            siteId: siteId
        )
        return try await self.updateSite(input, logger: logger)
    }

    /// Updates a VPC attachment.
    @Sendable
    @inlinable
    public func updateVpcAttachment(_ input: UpdateVpcAttachmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVpcAttachmentResponse {
        try await self.client.execute(
            operation: "UpdateVpcAttachment", 
            path: "/vpc-attachments/{AttachmentId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a VPC attachment.
    ///
    /// Parameters:
    ///   - addSubnetArns: Adds a subnet ARN to the VPC attachment.
    ///   - attachmentId: The ID of the attachment.
    ///   - options: Additional options for updating the VPC attachment.
    ///   - removeSubnetArns: Removes a subnet ARN from the attachment.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVpcAttachment(
        addSubnetArns: [String]? = nil,
        attachmentId: String,
        options: VpcOptions? = nil,
        removeSubnetArns: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVpcAttachmentResponse {
        let input = UpdateVpcAttachmentRequest(
            addSubnetArns: addSubnetArns, 
            attachmentId: attachmentId, 
            options: options, 
            removeSubnetArns: removeSubnetArns
        )
        return try await self.updateVpcAttachment(input, logger: logger)
    }
}

extension NetworkManager {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: NetworkManager, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension NetworkManager {
    /// Return PaginatorSequence for operation ``describeGlobalNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeGlobalNetworksPaginator(
        _ input: DescribeGlobalNetworksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeGlobalNetworksRequest, DescribeGlobalNetworksResponse> {
        return .init(
            input: input,
            command: self.describeGlobalNetworks,
            inputKey: \DescribeGlobalNetworksRequest.nextToken,
            outputKey: \DescribeGlobalNetworksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeGlobalNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkIds: The IDs of one or more global networks. The maximum is 10.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeGlobalNetworksPaginator(
        globalNetworkIds: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeGlobalNetworksRequest, DescribeGlobalNetworksResponse> {
        let input = DescribeGlobalNetworksRequest(
            globalNetworkIds: globalNetworkIds, 
            maxResults: maxResults
        )
        return self.describeGlobalNetworksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getConnectPeerAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getConnectPeerAssociationsPaginator(
        _ input: GetConnectPeerAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetConnectPeerAssociationsRequest, GetConnectPeerAssociationsResponse> {
        return .init(
            input: input,
            command: self.getConnectPeerAssociations,
            inputKey: \GetConnectPeerAssociationsRequest.nextToken,
            outputKey: \GetConnectPeerAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getConnectPeerAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - connectPeerIds: The IDs of the Connect peers.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func getConnectPeerAssociationsPaginator(
        connectPeerIds: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetConnectPeerAssociationsRequest, GetConnectPeerAssociationsResponse> {
        let input = GetConnectPeerAssociationsRequest(
            connectPeerIds: connectPeerIds, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults
        )
        return self.getConnectPeerAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getConnectionsPaginator(
        _ input: GetConnectionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetConnectionsRequest, GetConnectionsResponse> {
        return .init(
            input: input,
            command: self.getConnections,
            inputKey: \GetConnectionsRequest.nextToken,
            outputKey: \GetConnectionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - connectionIds: One or more connection IDs.
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func getConnectionsPaginator(
        connectionIds: [String]? = nil,
        deviceId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetConnectionsRequest, GetConnectionsResponse> {
        let input = GetConnectionsRequest(
            connectionIds: connectionIds, 
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults
        )
        return self.getConnectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCoreNetworkChangeEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCoreNetworkChangeEventsPaginator(
        _ input: GetCoreNetworkChangeEventsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCoreNetworkChangeEventsRequest, GetCoreNetworkChangeEventsResponse> {
        return .init(
            input: input,
            command: self.getCoreNetworkChangeEvents,
            inputKey: \GetCoreNetworkChangeEventsRequest.nextToken,
            outputKey: \GetCoreNetworkChangeEventsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCoreNetworkChangeEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - policyVersionId: The ID of the policy version.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCoreNetworkChangeEventsPaginator(
        coreNetworkId: String,
        maxResults: Int? = nil,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCoreNetworkChangeEventsRequest, GetCoreNetworkChangeEventsResponse> {
        let input = GetCoreNetworkChangeEventsRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            policyVersionId: policyVersionId
        )
        return self.getCoreNetworkChangeEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCoreNetworkChangeSet(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCoreNetworkChangeSetPaginator(
        _ input: GetCoreNetworkChangeSetRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCoreNetworkChangeSetRequest, GetCoreNetworkChangeSetResponse> {
        return .init(
            input: input,
            command: self.getCoreNetworkChangeSet,
            inputKey: \GetCoreNetworkChangeSetRequest.nextToken,
            outputKey: \GetCoreNetworkChangeSetResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCoreNetworkChangeSet(_:logger:)``.
    ///
    /// - Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - policyVersionId: The ID of the policy version.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCoreNetworkChangeSetPaginator(
        coreNetworkId: String,
        maxResults: Int? = nil,
        policyVersionId: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCoreNetworkChangeSetRequest, GetCoreNetworkChangeSetResponse> {
        let input = GetCoreNetworkChangeSetRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults, 
            policyVersionId: policyVersionId
        )
        return self.getCoreNetworkChangeSetPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCustomerGatewayAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCustomerGatewayAssociationsPaginator(
        _ input: GetCustomerGatewayAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCustomerGatewayAssociationsRequest, GetCustomerGatewayAssociationsResponse> {
        return .init(
            input: input,
            command: self.getCustomerGatewayAssociations,
            inputKey: \GetCustomerGatewayAssociationsRequest.nextToken,
            outputKey: \GetCustomerGatewayAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCustomerGatewayAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - customerGatewayArns: One or more customer gateway Amazon Resource Names (ARNs). The maximum is 10.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCustomerGatewayAssociationsPaginator(
        customerGatewayArns: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCustomerGatewayAssociationsRequest, GetCustomerGatewayAssociationsResponse> {
        let input = GetCustomerGatewayAssociationsRequest(
            customerGatewayArns: customerGatewayArns, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults
        )
        return self.getCustomerGatewayAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getDevicesPaginator(
        _ input: GetDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetDevicesRequest, GetDevicesResponse> {
        return .init(
            input: input,
            command: self.getDevices,
            inputKey: \GetDevicesRequest.nextToken,
            outputKey: \GetDevicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - deviceIds: One or more device IDs. The maximum is 10.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - siteId: The ID of the site.
    ///   - logger: Logger used for logging
    @inlinable
    public func getDevicesPaginator(
        deviceIds: [String]? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        siteId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetDevicesRequest, GetDevicesResponse> {
        let input = GetDevicesRequest(
            deviceIds: deviceIds, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            siteId: siteId
        )
        return self.getDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getLinkAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getLinkAssociationsPaginator(
        _ input: GetLinkAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetLinkAssociationsRequest, GetLinkAssociationsResponse> {
        return .init(
            input: input,
            command: self.getLinkAssociations,
            inputKey: \GetLinkAssociationsRequest.nextToken,
            outputKey: \GetLinkAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getLinkAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - deviceId: The ID of the device.
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkId: The ID of the link.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func getLinkAssociationsPaginator(
        deviceId: String? = nil,
        globalNetworkId: String,
        linkId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetLinkAssociationsRequest, GetLinkAssociationsResponse> {
        let input = GetLinkAssociationsRequest(
            deviceId: deviceId, 
            globalNetworkId: globalNetworkId, 
            linkId: linkId, 
            maxResults: maxResults
        )
        return self.getLinkAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getLinks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getLinksPaginator(
        _ input: GetLinksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetLinksRequest, GetLinksResponse> {
        return .init(
            input: input,
            command: self.getLinks,
            inputKey: \GetLinksRequest.nextToken,
            outputKey: \GetLinksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getLinks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - linkIds: One or more link IDs. The maximum is 10.
    ///   - maxResults: The maximum number of results to return.
    ///   - provider: The link provider.
    ///   - siteId: The ID of the site.
    ///   - type: The link type.
    ///   - logger: Logger used for logging
    @inlinable
    public func getLinksPaginator(
        globalNetworkId: String,
        linkIds: [String]? = nil,
        maxResults: Int? = nil,
        provider: String? = nil,
        siteId: String? = nil,
        type: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetLinksRequest, GetLinksResponse> {
        let input = GetLinksRequest(
            globalNetworkId: globalNetworkId, 
            linkIds: linkIds, 
            maxResults: maxResults, 
            provider: provider, 
            siteId: siteId, 
            type: type
        )
        return self.getLinksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getNetworkResourceCounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourceCountsPaginator(
        _ input: GetNetworkResourceCountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetNetworkResourceCountsRequest, GetNetworkResourceCountsResponse> {
        return .init(
            input: input,
            command: self.getNetworkResourceCounts,
            inputKey: \GetNetworkResourceCountsRequest.nextToken,
            outputKey: \GetNetworkResourceCountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getNetworkResourceCounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourceCountsPaginator(
        globalNetworkId: String,
        maxResults: Int? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetNetworkResourceCountsRequest, GetNetworkResourceCountsResponse> {
        let input = GetNetworkResourceCountsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            resourceType: resourceType
        )
        return self.getNetworkResourceCountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getNetworkResourceRelationships(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourceRelationshipsPaginator(
        _ input: GetNetworkResourceRelationshipsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetNetworkResourceRelationshipsRequest, GetNetworkResourceRelationshipsResponse> {
        return .init(
            input: input,
            command: self.getNetworkResourceRelationships,
            inputKey: \GetNetworkResourceRelationshipsRequest.nextToken,
            outputKey: \GetNetworkResourceRelationshipsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getNetworkResourceRelationships(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - registeredGatewayArn: The ARN of the registered gateway.
    ///   - resourceArn: The ARN of the gateway.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourceRelationshipsPaginator(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetNetworkResourceRelationshipsRequest, GetNetworkResourceRelationshipsResponse> {
        let input = GetNetworkResourceRelationshipsRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return self.getNetworkResourceRelationshipsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getNetworkResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourcesPaginator(
        _ input: GetNetworkResourcesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetNetworkResourcesRequest, GetNetworkResourcesResponse> {
        return .init(
            input: input,
            command: self.getNetworkResources,
            inputKey: \GetNetworkResourcesRequest.nextToken,
            outputKey: \GetNetworkResourcesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getNetworkResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - registeredGatewayArn: The ARN of the gateway.
    ///   - resourceArn: The ARN of the resource.
    ///   - resourceType: The resource type. The following are the supported resource types for Direct Connect:    dxcon     dx-gateway     dx-vif    The following are the supported resource types for Network Manager:    attachment     connect-peer     connection     core-network     device     link     peering     site    The following are the supported resource types for Amazon VPC:    customer-gateway     transit-gateway     transit-gateway-attachment     transit-gateway-connect-peer     transit-gateway-route-table     vpn-connection
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkResourcesPaginator(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetNetworkResourcesRequest, GetNetworkResourcesResponse> {
        let input = GetNetworkResourcesRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return self.getNetworkResourcesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getNetworkTelemetry(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkTelemetryPaginator(
        _ input: GetNetworkTelemetryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetNetworkTelemetryRequest, GetNetworkTelemetryResponse> {
        return .init(
            input: input,
            command: self.getNetworkTelemetry,
            inputKey: \GetNetworkTelemetryRequest.nextToken,
            outputKey: \GetNetworkTelemetryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getNetworkTelemetry(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The Amazon Web Services account ID.
    ///   - awsRegion: The Amazon Web Services Region.
    ///   - coreNetworkId: The ID of a core network.
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - registeredGatewayArn: The ARN of the gateway.
    ///   - resourceArn: The ARN of the resource.
    ///   - resourceType: The resource type. The following are the supported resource types:    connect-peer     transit-gateway-connect-peer     vpn-connection
    ///   - logger: Logger used for logging
    @inlinable
    public func getNetworkTelemetryPaginator(
        accountId: String? = nil,
        awsRegion: String? = nil,
        coreNetworkId: String? = nil,
        globalNetworkId: String,
        maxResults: Int? = nil,
        registeredGatewayArn: String? = nil,
        resourceArn: String? = nil,
        resourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetNetworkTelemetryRequest, GetNetworkTelemetryResponse> {
        let input = GetNetworkTelemetryRequest(
            accountId: accountId, 
            awsRegion: awsRegion, 
            coreNetworkId: coreNetworkId, 
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            registeredGatewayArn: registeredGatewayArn, 
            resourceArn: resourceArn, 
            resourceType: resourceType
        )
        return self.getNetworkTelemetryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getSitesPaginator(
        _ input: GetSitesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetSitesRequest, GetSitesResponse> {
        return .init(
            input: input,
            command: self.getSites,
            inputKey: \GetSitesRequest.nextToken,
            outputKey: \GetSitesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - siteIds: One or more site IDs. The maximum is 10.
    ///   - logger: Logger used for logging
    @inlinable
    public func getSitesPaginator(
        globalNetworkId: String,
        maxResults: Int? = nil,
        siteIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetSitesRequest, GetSitesResponse> {
        let input = GetSitesRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            siteIds: siteIds
        )
        return self.getSitesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getTransitGatewayConnectPeerAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getTransitGatewayConnectPeerAssociationsPaginator(
        _ input: GetTransitGatewayConnectPeerAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetTransitGatewayConnectPeerAssociationsRequest, GetTransitGatewayConnectPeerAssociationsResponse> {
        return .init(
            input: input,
            command: self.getTransitGatewayConnectPeerAssociations,
            inputKey: \GetTransitGatewayConnectPeerAssociationsRequest.nextToken,
            outputKey: \GetTransitGatewayConnectPeerAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getTransitGatewayConnectPeerAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - transitGatewayConnectPeerArns: One or more transit gateway Connect peer Amazon Resource Names (ARNs).
    ///   - logger: Logger used for logging
    @inlinable
    public func getTransitGatewayConnectPeerAssociationsPaginator(
        globalNetworkId: String,
        maxResults: Int? = nil,
        transitGatewayConnectPeerArns: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetTransitGatewayConnectPeerAssociationsRequest, GetTransitGatewayConnectPeerAssociationsResponse> {
        let input = GetTransitGatewayConnectPeerAssociationsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            transitGatewayConnectPeerArns: transitGatewayConnectPeerArns
        )
        return self.getTransitGatewayConnectPeerAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getTransitGatewayRegistrations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getTransitGatewayRegistrationsPaginator(
        _ input: GetTransitGatewayRegistrationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetTransitGatewayRegistrationsRequest, GetTransitGatewayRegistrationsResponse> {
        return .init(
            input: input,
            command: self.getTransitGatewayRegistrations,
            inputKey: \GetTransitGatewayRegistrationsRequest.nextToken,
            outputKey: \GetTransitGatewayRegistrationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getTransitGatewayRegistrations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - globalNetworkId: The ID of the global network.
    ///   - maxResults: The maximum number of results to return.
    ///   - transitGatewayArns: The Amazon Resource Names (ARNs) of one or more transit gateways. The maximum is 10.
    ///   - logger: Logger used for logging
    @inlinable
    public func getTransitGatewayRegistrationsPaginator(
        globalNetworkId: String,
        maxResults: Int? = nil,
        transitGatewayArns: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetTransitGatewayRegistrationsRequest, GetTransitGatewayRegistrationsResponse> {
        let input = GetTransitGatewayRegistrationsRequest(
            globalNetworkId: globalNetworkId, 
            maxResults: maxResults, 
            transitGatewayArns: transitGatewayArns
        )
        return self.getTransitGatewayRegistrationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAttachments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAttachmentsPaginator(
        _ input: ListAttachmentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAttachmentsRequest, ListAttachmentsResponse> {
        return .init(
            input: input,
            command: self.listAttachments,
            inputKey: \ListAttachmentsRequest.nextToken,
            outputKey: \ListAttachmentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAttachments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - attachmentType: The type of attachment.
    ///   - coreNetworkId: The ID of a core network.
    ///   - edgeLocation: The Region where the edge is located.
    ///   - maxResults: The maximum number of results to return.
    ///   - state: The state of the attachment.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAttachmentsPaginator(
        attachmentType: AttachmentType? = nil,
        coreNetworkId: String? = nil,
        edgeLocation: String? = nil,
        maxResults: Int? = nil,
        state: AttachmentState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAttachmentsRequest, ListAttachmentsResponse> {
        let input = ListAttachmentsRequest(
            attachmentType: attachmentType, 
            coreNetworkId: coreNetworkId, 
            edgeLocation: edgeLocation, 
            maxResults: maxResults, 
            state: state
        )
        return self.listAttachmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConnectPeers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConnectPeersPaginator(
        _ input: ListConnectPeersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConnectPeersRequest, ListConnectPeersResponse> {
        return .init(
            input: input,
            command: self.listConnectPeers,
            inputKey: \ListConnectPeersRequest.nextToken,
            outputKey: \ListConnectPeersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConnectPeers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - connectAttachmentId: The ID of the attachment.
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConnectPeersPaginator(
        connectAttachmentId: String? = nil,
        coreNetworkId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConnectPeersRequest, ListConnectPeersResponse> {
        let input = ListConnectPeersRequest(
            connectAttachmentId: connectAttachmentId, 
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults
        )
        return self.listConnectPeersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCoreNetworkPolicyVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoreNetworkPolicyVersionsPaginator(
        _ input: ListCoreNetworkPolicyVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCoreNetworkPolicyVersionsRequest, ListCoreNetworkPolicyVersionsResponse> {
        return .init(
            input: input,
            command: self.listCoreNetworkPolicyVersions,
            inputKey: \ListCoreNetworkPolicyVersionsRequest.nextToken,
            outputKey: \ListCoreNetworkPolicyVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCoreNetworkPolicyVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoreNetworkPolicyVersionsPaginator(
        coreNetworkId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCoreNetworkPolicyVersionsRequest, ListCoreNetworkPolicyVersionsResponse> {
        let input = ListCoreNetworkPolicyVersionsRequest(
            coreNetworkId: coreNetworkId, 
            maxResults: maxResults
        )
        return self.listCoreNetworkPolicyVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCoreNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoreNetworksPaginator(
        _ input: ListCoreNetworksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCoreNetworksRequest, ListCoreNetworksResponse> {
        return .init(
            input: input,
            command: self.listCoreNetworks,
            inputKey: \ListCoreNetworksRequest.nextToken,
            outputKey: \ListCoreNetworksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCoreNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCoreNetworksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCoreNetworksRequest, ListCoreNetworksResponse> {
        let input = ListCoreNetworksRequest(
            maxResults: maxResults
        )
        return self.listCoreNetworksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPeerings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPeeringsPaginator(
        _ input: ListPeeringsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPeeringsRequest, ListPeeringsResponse> {
        return .init(
            input: input,
            command: self.listPeerings,
            inputKey: \ListPeeringsRequest.nextToken,
            outputKey: \ListPeeringsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPeerings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - coreNetworkId: The ID of a core network.
    ///   - edgeLocation: Returns a list edge locations for the
    ///   - maxResults: The maximum number of results to return.
    ///   - peeringType: Returns a list of a peering requests.
    ///   - state: Returns a list of the peering request states.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPeeringsPaginator(
        coreNetworkId: String? = nil,
        edgeLocation: String? = nil,
        maxResults: Int? = nil,
        peeringType: PeeringType? = nil,
        state: PeeringState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPeeringsRequest, ListPeeringsResponse> {
        let input = ListPeeringsRequest(
            coreNetworkId: coreNetworkId, 
            edgeLocation: edgeLocation, 
            maxResults: maxResults, 
            peeringType: peeringType, 
            state: state
        )
        return self.listPeeringsPaginator(input, logger: logger)
    }
}

extension NetworkManager.DescribeGlobalNetworksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.DescribeGlobalNetworksRequest {
        return .init(
            globalNetworkIds: self.globalNetworkIds,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.GetConnectPeerAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetConnectPeerAssociationsRequest {
        return .init(
            connectPeerIds: self.connectPeerIds,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.GetConnectionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetConnectionsRequest {
        return .init(
            connectionIds: self.connectionIds,
            deviceId: self.deviceId,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.GetCoreNetworkChangeEventsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetCoreNetworkChangeEventsRequest {
        return .init(
            coreNetworkId: self.coreNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            policyVersionId: self.policyVersionId
        )
    }
}

extension NetworkManager.GetCoreNetworkChangeSetRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetCoreNetworkChangeSetRequest {
        return .init(
            coreNetworkId: self.coreNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            policyVersionId: self.policyVersionId
        )
    }
}

extension NetworkManager.GetCustomerGatewayAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetCustomerGatewayAssociationsRequest {
        return .init(
            customerGatewayArns: self.customerGatewayArns,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.GetDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetDevicesRequest {
        return .init(
            deviceIds: self.deviceIds,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            siteId: self.siteId
        )
    }
}

extension NetworkManager.GetLinkAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetLinkAssociationsRequest {
        return .init(
            deviceId: self.deviceId,
            globalNetworkId: self.globalNetworkId,
            linkId: self.linkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.GetLinksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetLinksRequest {
        return .init(
            globalNetworkId: self.globalNetworkId,
            linkIds: self.linkIds,
            maxResults: self.maxResults,
            nextToken: token,
            provider: self.provider,
            siteId: self.siteId,
            type: self.type
        )
    }
}

extension NetworkManager.GetNetworkResourceCountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetNetworkResourceCountsRequest {
        return .init(
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            resourceType: self.resourceType
        )
    }
}

extension NetworkManager.GetNetworkResourceRelationshipsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetNetworkResourceRelationshipsRequest {
        return .init(
            accountId: self.accountId,
            awsRegion: self.awsRegion,
            coreNetworkId: self.coreNetworkId,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            registeredGatewayArn: self.registeredGatewayArn,
            resourceArn: self.resourceArn,
            resourceType: self.resourceType
        )
    }
}

extension NetworkManager.GetNetworkResourcesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetNetworkResourcesRequest {
        return .init(
            accountId: self.accountId,
            awsRegion: self.awsRegion,
            coreNetworkId: self.coreNetworkId,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            registeredGatewayArn: self.registeredGatewayArn,
            resourceArn: self.resourceArn,
            resourceType: self.resourceType
        )
    }
}

extension NetworkManager.GetNetworkTelemetryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetNetworkTelemetryRequest {
        return .init(
            accountId: self.accountId,
            awsRegion: self.awsRegion,
            coreNetworkId: self.coreNetworkId,
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            registeredGatewayArn: self.registeredGatewayArn,
            resourceArn: self.resourceArn,
            resourceType: self.resourceType
        )
    }
}

extension NetworkManager.GetSitesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetSitesRequest {
        return .init(
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            siteIds: self.siteIds
        )
    }
}

extension NetworkManager.GetTransitGatewayConnectPeerAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetTransitGatewayConnectPeerAssociationsRequest {
        return .init(
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            transitGatewayConnectPeerArns: self.transitGatewayConnectPeerArns
        )
    }
}

extension NetworkManager.GetTransitGatewayRegistrationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.GetTransitGatewayRegistrationsRequest {
        return .init(
            globalNetworkId: self.globalNetworkId,
            maxResults: self.maxResults,
            nextToken: token,
            transitGatewayArns: self.transitGatewayArns
        )
    }
}

extension NetworkManager.ListAttachmentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.ListAttachmentsRequest {
        return .init(
            attachmentType: self.attachmentType,
            coreNetworkId: self.coreNetworkId,
            edgeLocation: self.edgeLocation,
            maxResults: self.maxResults,
            nextToken: token,
            state: self.state
        )
    }
}

extension NetworkManager.ListConnectPeersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.ListConnectPeersRequest {
        return .init(
            connectAttachmentId: self.connectAttachmentId,
            coreNetworkId: self.coreNetworkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.ListCoreNetworkPolicyVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.ListCoreNetworkPolicyVersionsRequest {
        return .init(
            coreNetworkId: self.coreNetworkId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.ListCoreNetworksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.ListCoreNetworksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension NetworkManager.ListPeeringsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> NetworkManager.ListPeeringsRequest {
        return .init(
            coreNetworkId: self.coreNetworkId,
            edgeLocation: self.edgeLocation,
            maxResults: self.maxResults,
            nextToken: token,
            peeringType: self.peeringType,
            state: self.state
        )
    }
}
